| #!groovy |
| |
| funcs = evaluate readTrusted( 'TestON/JenkinsFile/JenkinsCommonFuncs.groovy' ) |
| test_lists = evaluate readTrusted( 'TestON/JenkinsFile/JenkinsTestONTests.groovy' ) |
| |
| previous_version = "1.12" |
| before_previous_version = "1.11" |
| funcs.initializeTrend( "VM" ); |
| wikiContents = "" |
| testcases = [ |
| "FUNC" : [ tests : "" , nodeName : "VM", wikiContent : "" ], |
| "HA" : [ tests : "" , nodeName : "VM", wikiContent : "" ], |
| "SCPF" : [ tests : "" , nodeName : "BM", wikiContent : "" ], |
| "SR" : [ tests : "", nodeName : "VM", wikiContent : "" ], |
| "USECASE" : [ tests : "" , nodeName : "BM", wikiContent : "" ] |
| ] |
| Prefix_organizer = [ |
| "FU" : "FUNC", |
| "HA" : "HA", |
| "PL" : "USECASE", |
| "SA" : "USECASE", |
| "SC" : "SCPF", |
| "SR" : "SR", |
| "US" : "USECASE", |
| "VP" : "USECASE" |
| ] |
| |
| manually_run = params.manual_run |
| onos_b = "master" |
| test_branch = "" |
| onos_tag = params.ONOSTag |
| isOldFlow = true |
| |
| // Set tests based on day of week |
| def now = funcs.getCurrentTime() |
| print now.toString() |
| today = now[ Calendar.DAY_OF_WEEK ] |
| |
| if ( manually_run ){ |
| onos_b = params.ONOSVersion |
| } else { |
| if ( today == Calendar.SATURDAY ){ |
| onos_b = previous_version |
| } else if( today == Calendar.SUNDAY ){ |
| onos_b = before_previous_version |
| } |
| } |
| AllTheTests = test_lists.getAllTheTests( onos_b ) |
| |
| day = "" |
| SCPF_choices = "" |
| USECASE_choices = "" |
| FUNC_choices = "" |
| HA_choices = "" |
| SR_choices = "" |
| stat_graph_generator_file = "testCategoryBuildStats.R" |
| pie_graph_generator_file = "testCategoryPiePassFail.R" |
| graph_saved_directory = "/var/jenkins/workspace/postjob-VM/" |
| |
| post_result = params.PostResult |
| if( !manually_run ){ |
| slackSend( color:'#03CD9F', |
| message:":sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles:\n" |
| + "Starting tests on : " + now.toString() |
| + "\n:sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles::sparkles:" ) |
| testDivider( today ) |
| FUNC_choices = lastCommaRemover( FUNC_choices ) |
| HA_choices = lastCommaRemover( HA_choices ) |
| SCPF_choices = lastCommaRemover( SCPF_choices ) |
| USECASE_choices = lastCommaRemover( USECASE_choices ) |
| SR_choices = lastCommaRemover( SR_choices ) |
| } |
| |
| if ( manually_run ){ |
| organize_tests( params.Tests ) |
| |
| isOldFlow = params.isOldFlow |
| println "Tests to be run manually : " |
| }else{ |
| testcases[ "SCPF" ][ "tests" ] = SCPF_choices |
| testcases[ "USECASE" ][ "tests" ] = USECASE_choices |
| testcases[ "FUNC" ][ "tests" ] = FUNC_choices |
| testcases[ "HA" ][ "tests" ] = HA_choices |
| testcases[ "SR" ][ "tests" ] = SR_choices |
| println "Defaulting to " + day + " tests:" |
| } |
| |
| print_tests( testcases ) |
| |
| def runTest = [ |
| "VM" : [:], |
| "BM" : [:] |
| ] |
| for( String test in testcases.keySet() ){ |
| println test |
| if ( testcases[ test ][ "tests" ] != "" ){ |
| runTest[ testcases[ test ][ "nodeName" ] ][ test ] = trigger_pipeline( onos_b, testcases[ test ][ "tests" ], testcases[ test ][ "nodeName" ], test, manually_run, onos_tag ) |
| } |
| } |
| def finalList = [:] |
| finalList[ "VM" ] = runTestSeq( runTest[ "VM" ] ) |
| finalList[ "BM" ] = runTestSeq( runTest[ "BM" ] ) |
| parallel finalList |
| //finalList[ "BM" ].call() |
| |
| if ( !manually_run ){ |
| funcs.generateStatGraph( funcs.branchWithPrefix( onos_b ), |
| AllTheTests, |
| stat_graph_generator_file, |
| pie_graph_generator_file, |
| graph_saved_directory ) |
| } |
| |
| def testDivider( today ){ |
| switch ( today ) { |
| case Calendar.MONDAY: |
| initHtmlForWiki() |
| monday( true ) |
| tuesday( true, false ) |
| wednesday( true, false ) |
| thursday( true, false ) |
| friday( true, false ) |
| saturday( false, false ) |
| sunday( false, false ) |
| day = "Monday" |
| closeHtmlForWiki() |
| postToWiki( wikiContents ) |
| slackSend( color:'#FFD988', message:"Tests to be run this weekdays : \n" + printDaysForTest() ) |
| break |
| case Calendar.TUESDAY: |
| tuesday( false, true ) |
| day = "Tuesday" |
| break |
| case Calendar.WEDNESDAY: |
| wednesday( false, true ) |
| day = "Wednesday" |
| break |
| case Calendar.THURSDAY: |
| thursday( false, true ) |
| day = "Thursday" |
| break |
| case Calendar.FRIDAY: |
| friday( false, true ) |
| day = "Friday" |
| break |
| case Calendar.SATURDAY: |
| saturday( false, true ) |
| day = "Saturday" |
| break |
| case Calendar.SUNDAY: |
| sunday( false , true ) |
| day = "Sunday" |
| isOldFlow = false |
| break |
| } |
| } |
| def printDaysForTest(){ |
| result = "" |
| for ( String test in AllTheTests.keySet() ){ |
| result += test + " : \n" |
| for( String each in AllTheTests[ test ].keySet() ){ |
| AllTheTests[ test ][ each ][ "day" ] = lastCommaRemover( AllTheTests[ test ][ each ][ "day" ] ) |
| result += " " + each + ":[" + AllTheTests[ test ][ each ][ "day" ] + "]\n" |
| } |
| result += "\n" |
| } |
| return result |
| } |
| def lastCommaRemover( str ){ |
| if ( str.size() > 0 && str[ str.size() - 1 ] == ',' ){ |
| str = str.substring( 0,str.size() - 1 ) |
| } |
| return str |
| } |
| def monday( getResult ){ |
| addingHeader( "FUNC" ) |
| FUNC_choices += adder( "FUNC", "basic", true, "M", getResult ) |
| FUNC_choices += adder( "FUNC", "new_Test", true, "M", getResult ) |
| FUNC_choices += adder( "FUNC", "extra_A", true, "M", getResult ) |
| closingHeader( "FUNC" ) |
| addingHeader( "HA" ) |
| HA_choices += adder( "HA", "basic", true, "M", getResult ) |
| HA_choices += adder( "HA", "extra_A", true, "M", getResult ) |
| //HA_choices += adder( "HA", "new_Test", true, "M", getResult ) |
| closingHeader( "HA" ) |
| addingHeader( "SCPF" ) |
| SCPF_choices += adder( "SCPF", "basic", true, "M", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_B", true, "M", getResult ) |
| closingHeader( "SCPF" ) |
| addingHeader( "SR" ) |
| SR_choices += adder( "SR", "basic", true, "M", getResult ) |
| closingHeader( "SR" ) |
| addingHeader( "USECASE" ) |
| closingHeader( "USECASE" ) |
| } |
| def tuesday( getDay, getResult ){ |
| |
| addingHeader( "FUNC" ) |
| FUNC_choices += adder( "FUNC", "basic", getDay, "T", getResult ) |
| FUNC_choices += adder( "FUNC", "new_Test", getDay, "T", getResult ) |
| FUNC_choices += adder( "FUNC", "extra_B", getDay, "T", getResult ) |
| closingHeader( "FUNC" ) |
| addingHeader( "HA" ) |
| HA_choices += adder( "HA", "basic", getDay, "T", getResult ) |
| HA_choices += adder( "HA", "extra_B", getDay, "T", getResult ) |
| HA_choices += adder( "HA", "new_Test", getDay, "T", getResult ) |
| closingHeader( "HA" ) |
| addingHeader( "SCPF" ) |
| SCPF_choices += adder( "SCPF", "basic", getDay, "T", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_C", getDay, "T", getResult ) |
| closingHeader( "SCPF" ) |
| addingHeader( "SR" ) |
| SR_choices += adder( "SR", "basic", getDay, "T", getResult ) |
| closingHeader( "SR" ) |
| addingHeader( "USECASE" ) |
| USECASE_choices += adder( "USECASE", "basic", getDay, "T", getResult ) |
| USECASE_choices += adder( "USECASE", "extra_A", getDay, "T", getResult ) |
| closingHeader( "USECASE" ) |
| } |
| def wednesday( getDay, getResult ){ |
| addingHeader( "FUNC" ) |
| FUNC_choices += adder( "FUNC", "basic", getDay, "W", getResult ) |
| FUNC_choices += adder( "FUNC", "new_Test", getDay, "W", getResult ) |
| FUNC_choices += adder( "FUNC", "extra_A", getDay, "W", getResult ) |
| closingHeader( "FUNC" ) |
| addingHeader( "HA" ) |
| HA_choices += adder( "HA", "basic", getDay, "W", getResult ) |
| HA_choices += adder( "HA", "extra_A", getDay, "W", getResult ) |
| //HA_choices += adder( "HA", "new_Test", getDay, "W", getResult ) |
| closingHeader( "HA" ) |
| addingHeader( "SCPF" ) |
| SCPF_choices += adder( "SCPF", "basic", getDay, "W", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_A", getDay, "W", getResult ) |
| SCPF_choices += adder( "SCPF", "new_Test", getDay, "W", getResult ) |
| closingHeader( "SCPF" ) |
| addingHeader( "SR" ) |
| SR_choices += adder( "SR", "basic", getDay, "W", getResult ) |
| closingHeader( "SR" ) |
| addingHeader( "USECASE" ) |
| closingHeader( "USECASE" ) |
| } |
| def thursday( getDay, getResult ){ |
| addingHeader( "FUNC" ) |
| FUNC_choices += adder( "FUNC", "basic", getDay, "Th", getResult ) |
| FUNC_choices += adder( "FUNC", "new_Test", getDay, "Th", getResult ) |
| FUNC_choices += adder( "FUNC", "extra_B", getDay, "Th", getResult ) |
| closingHeader( "FUNC" ) |
| addingHeader( "HA" ) |
| HA_choices += adder( "HA", "basic", getDay, "Th", getResult ) |
| HA_choices += adder( "HA", "extra_B", getDay, "Th", getResult ) |
| HA_choices += adder( "HA", "new_Test", getDay, "Th", getResult ) |
| closingHeader( "HA" ) |
| addingHeader( "SCPF" ) |
| SCPF_choices += adder( "SCPF", "basic", getDay, "Th", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_B", getDay, "Th", getResult ) |
| closingHeader( "SCPF" ) |
| addingHeader( "SR" ) |
| SR_choices += adder( "SR", "basic", getDay, "Th", getResult ) |
| closingHeader( "SR" ) |
| addingHeader( "USECASE" ) |
| closingHeader( "USECASE" ) |
| } |
| def friday( getDay, getResult ){ |
| addingHeader( "FUNC" ) |
| FUNC_choices += adder( "FUNC", "basic", getDay, "F", getResult ) |
| FUNC_choices += adder( "FUNC", "new_Test", getDay, "F", getResult ) |
| FUNC_choices += adder( "FUNC", "extra_A", getDay, "F", getResult ) |
| closingHeader( "FUNC" ) |
| addingHeader( "HA" ) |
| HA_choices += adder( "HA", "basic", getDay, "F", getResult ) |
| HA_choices += adder( "HA", "extra_A", getDay, "F", getResult ) |
| //HA_choices += adder( "HA", "new_Test", getDay, "F", getResult ) |
| closingHeader( "HA" ) |
| addingHeader( "SCPF" ) |
| SCPF_choices += adder( "SCPF", "basic", getDay, "F", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_A", getDay, "F", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_D", getDay, "F", getResult ) |
| closingHeader( "SCPF" ) |
| addingHeader( "SR" ) |
| SR_choices += adder( "SR", "basic", getDay, "F", getResult ) |
| closingHeader( "SR" ) |
| addingHeader( "USECASE" ) |
| closingHeader( "USECASE" ) |
| } |
| def saturday( getDay, getResult ){ |
| addingHeader( "FUNC" ) |
| FUNC_choices += adder( "FUNC", "basic", getDay, "Sa", getResult ) |
| FUNC_choices += adder( "FUNC", "extra_A", getDay, "Sa", getResult ) |
| FUNC_choices += adder( "FUNC", "extra_B", getDay, "Sa", getResult ) |
| FUNC_choices += adder( "FUNC", "new_Test", getDay, "Sa", getResult ) |
| closingHeader( "FUNC" ) |
| addingHeader( "HA" ) |
| HA_choices += adder( "HA", "basic", getDay, "Sa", getResult ) |
| HA_choices += adder( "HA", "extra_A", getDay, "Sa", getResult ) |
| HA_choices += adder( "HA", "extra_B", getDay, "Sa", getResult ) |
| HA_choices += adder( "HA", "new_Test", getDay, "Sa", getResult ) |
| closingHeader( "HA" ) |
| addingHeader( "SCPF" ) |
| SCPF_choices += adder( "SCPF", "basic", getDay, "Sa", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_A", getDay, "Sa", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_B", getDay, "Sa", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_C", getDay, "Sa", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_D", getDay, "Sa", getResult ) |
| SCPF_choices += adder( "SCPF", "new_Test", getDay, "Sa", getResult ) |
| closingHeader( "SCPF" ) |
| addingHeader( "SR" ) |
| SR_choices += adder( "SR", "basic", getDay, "Sa", getResult ) |
| closingHeader( "SR" ) |
| addingHeader( "USECASE" ) |
| USECASE_choices += adder( "USECASE", "basic", getDay, "Sa", getResult ) |
| closingHeader( "USECASE" ) |
| } |
| def sunday( getDay, getResult ){ |
| addingHeader( "FUNC" ) |
| FUNC_choices += adder( "FUNC", "basic", getDay, "S", getResult ) |
| FUNC_choices += adder( "FUNC", "extra_A", getDay, "S", getResult ) |
| FUNC_choices += adder( "FUNC", "extra_B", getDay, "S", getResult ) |
| closingHeader( "FUNC" ) |
| addingHeader( "HA" ) |
| HA_choices += adder( "HA", "basic", getDay, "S", getResult ) |
| HA_choices += adder( "HA", "extra_A", getDay, "S", getResult ) |
| HA_choices += adder( "HA", "extra_B", getDay, "S", getResult ) |
| closingHeader( "HA" ) |
| addingHeader( "SCPF" ) |
| SCPF_choices += adder( "SCPF", "basic", getDay, "S", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_A", getDay, "S", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_B", getDay, "S", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_C", getDay, "S", getResult ) |
| SCPF_choices += adder( "SCPF", "extra_D", getDay, "S", getResult ) |
| closingHeader( "SCPF" ) |
| addingHeader( "SR" ) |
| SR_choices += adder( "SR", "basic", getDay, "S", getResult ) |
| closingHeader( "SR" ) |
| addingHeader( "USECASE" ) |
| USECASE_choices += adder( "USECASE", "basic", getDay, "S", getResult ) |
| closingHeader( "USECASE" ) |
| } |
| def adder( testCat, set, dayAdding, day, getResult ){ |
| result = "" |
| for( String test in AllTheTests[ testCat ].keySet() ){ |
| if( AllTheTests[ testCat ][ test ][ set ] ){ |
| if( getResult ) |
| result += test + "," |
| if( dayAdding ) |
| dayAdder( testCat, test, day ) |
| makeHtmlColList( testCat, test ) |
| } |
| } |
| return result |
| } |
| def initHtmlForWiki(){ |
| wikiContents = ''' |
| <table class="wrapped confluenceTable"> |
| <colgroup> |
| <col /> |
| <col /> |
| <col /> |
| <col /> |
| <col /> |
| <col /> |
| </colgroup> |
| <tbody> |
| <tr> |
| <th colspan="1" class="confluenceTh"> |
| <br /> |
| </th> |
| <th class="confluenceTh"><p>Monday</p></th> |
| <th class="confluenceTh"><p>Tuesday</p></th> |
| <th class="confluenceTh"><p>Wednesday</p></th> |
| <th class="confluenceTh"><p>Thursday</p></th> |
| <th class="confluenceTh"><p>Friday</p></th> |
| <th class="confluenceTh"><p>Saturday</p></th> |
| <th class="confluenceTh"><p>Sunday</p></th> |
| </tr>''' |
| for( String test in testcases.keySet() ){ |
| testcases[ test ][ 'wikiContent' ] = ''' |
| <tr> |
| <th colspan="1" class="confluenceTh">''' + test + '''</th>''' |
| } |
| } |
| def addingHeader( testCategory ){ |
| testcases[ testCategory ][ 'wikiContent' ] += ''' |
| <td class="confluenceTd"> |
| <ul>''' |
| } |
| def makeHtmlColList( testCategory, testName ){ |
| testcases[ testCategory ][ 'wikiContent' ] += ''' |
| <li>'''+ testName +'''</li>''' |
| |
| } |
| def closingHeader( testCategory ){ |
| testcases[ testCategory ][ 'wikiContent' ] += ''' |
| </ul> |
| </td>''' |
| } |
| def closeHtmlForWiki(){ |
| for( String test in testcases.keySet() ){ |
| wikiContents += testcases[ test ][ 'wikiContent' ] |
| wikiContents += ''' |
| </tr>''' |
| } |
| wikiContents += ''' |
| </tbody> |
| </table> |
| <p><strong>Everyday</strong>, all SegmentRouting tests are built and run on every branch.</p> |
| <p>On <strong>Weekdays</strong>, all the other tests are built and run on the master branch.</p> |
| <p>On <strong>Saturdays</strong>, all the other tests are built and run on the '''+ funcs.branchWithPrefix( previous_version ) +''' branch.</p> |
| <p>On <strong>Sundays</strong>, all the other tests are built and run on the '''+ funcs.branchWithPrefix( before_previous_version ) +''' branch.</p>''' |
| } |
| def postToWiki( contents ){ |
| node( testMachine ){ |
| workspace = "/var/jenkins/workspace/all-pipeline-trigger/" |
| filename = "jenkinsSchedule.txt" |
| writeFile file: workspace + filename, text: contents |
| funcs.publishToConfluence( "false", "true", |
| "Automated Test Schedule", |
| workspace + filename ) |
| } |
| } |
| def dayAdder( testCat, testName, dayOfWeek ){ |
| AllTheTests[ testCat ][ testName ][ "day" ] += dayOfWeek + "," |
| } |
| def runTestSeq( testList ){ |
| return{ |
| for ( test in testList.keySet() ){ |
| testList[ test ].call() |
| } |
| } |
| } |
| |
| def print_tests( tests ){ |
| for( String test in tests.keySet() ){ |
| if( tests[ test ][ "tests" ] != "" ){ |
| println test + ":" |
| println tests[ test ][ "tests" ] |
| } |
| } |
| } |
| def organize_tests( tests ){ |
| testList = tests.tokenize( "\n;, " ) |
| for( String test in testList ) |
| testcases [ Prefix_organizer[ ( test == "FUNCbgpls" || test == "FUNCvirNetNB" ? "US" : ( test[ 0 ] + test[ 1 ] ) ) ] ][ "tests" ] += test + "," |
| } |
| def borrow_mn( jobOn ){ |
| result = "" |
| if( jobOn == "SR" ){ |
| result = "~/cell_borrow.sh" |
| } |
| return result |
| } |
| def trigger( branch, tests, nodeName, jobOn, manuallyRun, onosTag ){ |
| println jobOn + "-pipeline-" + manuallyRun ? "manually" : branch |
| wiki = branch |
| branch = funcs.branchWithPrefix( branch ) |
| test_branch = "master" |
| node( "TestStation-" + nodeName + "s" ){ |
| envSetup( branch, test_branch, onosTag, jobOn, manuallyRun ) |
| |
| exportEnvProperty( branch, test_branch, wiki, tests, post_result, manuallyRun, onosTag, isOldFlow ) |
| } |
| |
| jobToRun = jobOn + "-pipeline-" + ( manuallyRun ? "manually" : wiki ) |
| build job: jobToRun, propagate: false |
| } |
| def trigger_pipeline( branch, tests, nodeName, jobOn, manuallyRun, onosTag ){ |
| // nodeName : "BM" or "VM" |
| // jobOn : "SCPF" or "USECASE" or "FUNC" or "HA" |
| return{ |
| if( jobOn == "SR" ){ |
| trigger( "1.11", tests, nodeName, jobOn, manuallyRun, onosTag ) |
| trigger( "1.12", tests, nodeName, jobOn, manuallyRun, onosTag ) |
| trigger( "master", tests, nodeName, jobOn, manuallyRun, onosTag ) |
| // returnCell( nodeName ) |
| }else{ |
| trigger( branch, tests, nodeName, jobOn, manuallyRun, onosTag ) |
| } |
| } |
| } |
| // export Environment properties. |
| def exportEnvProperty( onos_branch, test_branch, wiki, tests, postResult, manually_run, onosTag, isOldFlow ){ |
| stage( "export Property" ){ |
| sh ''' |
| echo "ONOSBranch=''' + onos_branch +'''" > /var/jenkins/TestONOS.property |
| echo "TestONBranch=''' + test_branch +'''" >> /var/jenkins/TestONOS.property |
| echo "ONOSTag='''+ onosTag +'''" >> /var/jenkins/TestONOS.property |
| echo "WikiPrefix=''' + wiki +'''" >> /var/jenkins/TestONOS.property |
| echo "ONOSJVMHeap='''+ env.ONOSJVMHeap +'''" >> /var/jenkins/TestONOS.property |
| echo "Tests=''' + tests +'''" >> /var/jenkins/TestONOS.property |
| echo "postResult=''' + postResult +'''" >> /var/jenkins/TestONOS.property |
| echo "manualRun=''' + manually_run +'''" >> /var/jenkins/TestONOS.property |
| echo "isOldFlow=''' + isOldFlow +'''" >> /var/jenkins/TestONOS.property |
| |
| ''' |
| } |
| } |
| // Initialize the environment Setup for the onos and OnosSystemTest |
| def envSetup( onos_branch, test_branch, onos_tag, jobOn, manuallyRun ){ |
| stage( "envSetup" ) { |
| // after env: ''' + borrow_mn( jobOn ) + ''' |
| sh '''#!/bin/bash -l |
| set +e |
| . ~/.bashrc |
| env |
| ''' + preSetup( onos_branch, test_branch, onos_tag, manuallyRun ) + ''' |
| ''' + oldFlowCheck( jobOn, onos_branch ) + ''' |
| ''' + postSetup( onos_branch, test_branch, onos_tag, manuallyRun ) |
| } |
| } |
| def tagCheck( onos_tag, onos_branch ){ |
| result = "git checkout " |
| if ( onos_tag == "" ) |
| result += onos_branch //create new local branch |
| else |
| result += onos_tag //checkout the tag |
| return result |
| } |
| def preSetup( onos_branch, test_branch, onos_tag, isManual ){ |
| result = "" |
| if( !isManual ){ |
| result = '''echo -e "\n##### Set TestON Branch #####" |
| echo "TestON Branch is set on: ''' + test_branch + '''" |
| |
| cd ~/OnosSystemTest/ |
| git checkout HEAD~1 # Make sure you aren't pn a branch |
| git branch | grep -v "detached from" | xargs git branch -d # delete all local branches merged with remote |
| git branch -D ''' + test_branch + ''' # just incase there are local changes. This will normally result in a branch not found error |
| git clean -df # clean any local files |
| git fetch --all # update all caches from remotes |
| git reset --hard origin/''' + test_branch +''' # force local index to match remote branch |
| git clean -df # clean any local files |
| git checkout ''' + test_branch + ''' #create new local branch |
| git branch |
| git log -1 --decorate |
| |
| |
| echo -e "\n##### Set ONOS Branch #####" |
| echo "ONOS Branch is set on: ''' + onos_branch + '''" |
| |
| echo -e "\n #### check karaf version ######" |
| env |grep karaf |
| |
| cd ~/onos |
| rm -rf buck-out/* |
| ~/onos/tools/build/onos-buck clean |
| git checkout HEAD~1 # Make sure you aren't pn a branch |
| git branch | grep -v "detached from" | xargs git branch -d # delete all local branches merged with remote |
| git branch -D ''' + onos_branch + ''' # just incase there are local changes. This will normally result in a branch not found error |
| git clean -df # clean any local files |
| git fetch --all # update all caches from remotes |
| git reset --hard origin/''' + onos_branch + ''' # force local index to match remote branch |
| git clean -df # clean any local files |
| ''' + tagCheck( onos_tag, onos_branch ) + ''' |
| git branch |
| git log -1 --decorate |
| |
| |
| echo -e "\n##### set jvm heap size to 8G #####" |
| echo ${ONOSJVMHeap} |
| |
| inserted_line="export JAVA_OPTS=\"\${ONOSJVMHeap}\"" |
| sed -i "s/bash/bash\\n$inserted_line/" ~/onos/tools/package/bin/onos-service |
| |
| echo "##### Check onos-service setting..... #####" |
| cat ~/onos/tools/package/bin/onos-service |
| |
| export JAVA_HOME=/usr/lib/jvm/java-8-oracle''' |
| } |
| return result |
| } |
| def oldFlowCheck( jobOn, onos_branch ){ |
| result = "" |
| if( jobOn == "SCPF" && ( onos_branch== "master" || onos_branch=="onos-1.12" ) ) |
| result = '''sed -i -e 's/@Component(immediate = true)/@Component(enabled = false)/g' ~/onos/core/store/dist/src/main/java/org/onosproject/store/flow/impl/''' + ( isOldFlow ? "DistributedFlowRuleStore" : "ECFlowRuleStore" ) + '''.java |
| sed -i -e 's/@Component(enabled = false)/@Component(immediate = true)/g' ~/onos/core/store/dist/src/main/java/org/onosproject/store/flow/impl/''' + ( isOldFlow ? "ECFlowRuleStore" : "DistributedFlowRuleStore" ) + ".java" |
| return result |
| } |
| def postSetup( onos_branch, test_branch, onos_tag, isManual ){ |
| result = "" |
| if( !isManual ){ |
| result = '''echo -e "\n##### build ONOS skip unit tests ######" |
| #mvn clean install -DskipTests |
| # Force buck update |
| rm -f ~/onos/bin/buck |
| ~/onos/tools/build/onos-buck build onos |
| |
| sleep 30 |
| echo -e "\n##### Stop all running instances of Karaf #####" |
| kill $(ps -efw | grep karaf | grep -v grep | awk '{print $2}') |
| sleep 30 |
| |
| git branch''' |
| } |
| return result |
| } |
| def returnCell( nodeName ){ |
| node( "TestStation-" + nodeName + "s" ){ |
| sh '''#!/bin/bash -l |
| set +e |
| . ~/.bashrc |
| env |
| ~/./return_cell.sh |
| ''' |
| } |
| } |